{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f5bb572",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "import random\n",
    "import time\n",
    "from cvxopt import spmatrix\n",
    "import heapq\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d650c0",
   "metadata": {},
   "source": [
    "数据处理部分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "130c167c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集中的电影部数：7142\n",
      "数据集中的用户数：597\n"
     ]
    }
   ],
   "source": [
    "df=pd.read_csv('E:/推荐系统/数据集/MovieLens/ml-latest/ratings.csv')\n",
    "df_copy1=df.copy()     #正负反馈皆有\n",
    "df_copy2=df.copy()      \n",
    "df_copy2=df_copy1[df_copy1['rating']>2.9]     #只有正反馈\n",
    "df=df_copy2.iloc[:50000].sample(frac=1)[['userId','movieId']]\n",
    "print(\"数据集中的电影部数：%d\"%len(df['movieId'].unique()))\n",
    "print(\"数据集中的用户数：%d\"%len(df['userId'].unique()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6c055a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#按比例划分训练集和测试集\n",
    "proportion=0.8\n",
    "train=df.iloc[0:int(proportion*df.shape[0])]\n",
    "test=df.iloc[int(proportion*df.shape[0]):]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f71cb3a",
   "metadata": {},
   "source": [
    "定义需要的函数，获取中间量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "af2c7b04",
   "metadata": {},
   "outputs": [],
   "source": [
    "#物品流行度计算函数：\n",
    "def items_popularity(train):\n",
    "    train_copy=train.copy()\n",
    "    train_copy['popularity']=1\n",
    "    df_movie_popularity=train_copy.groupby('movieId').agg('sum').reset_index()\n",
    "    df_movie_popularity=df_movie_popularity[['movieId','popularity']]\n",
    "    df_movie_popularity\n",
    "    return df_movie_popularity\n",
    "#计算物品流行度，主要为了后面计算推荐名单结果的流行度\n",
    "df_movie_popularity=items_popularity(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b6a48343",
   "metadata": {},
   "outputs": [],
   "source": [
    "#计算用户兴趣相似度矩阵W\n",
    "'''\n",
    "建立物品-用户倒排表，找到交互过一个物品的所有用户，累积更新两两用户之间的兴趣相似度。\n",
    "W:存储了两两用户的相似度，实际上存储了用户相似度矩阵的所有元素。\n",
    "N：每个用户交互过的物品总数，W[i][j]=C[i][j]/(N[i]*N[j])\n",
    "df_W:将用户相似度矩阵W存储为DataFrame形式。\n",
    "'''\n",
    "def users_relevance_matrix(train):\n",
    "    C={}\n",
    "    N={}\n",
    "    for name, result in train.groupby('movieId'):\n",
    "        result=result.reset_index()\n",
    "        for j in range(result.shape[0]):\n",
    "            if result.iloc[j]['userId'] not in N:\n",
    "                N[result.iloc[j]['userId']]=0\n",
    "            N[result.iloc[j]['userId']]+=1\n",
    "            for k in range(j+1,result.shape[0]):\n",
    "                if result.iloc[k]['userId']==result.iloc[j]['userId']:\n",
    "                    continue\n",
    "                else:\n",
    "                    if (result.iloc[j]['userId'],result.iloc[k]['userId']) not in C:\n",
    "                        C[result.iloc[j]['userId'],result.iloc[k]['userId']]=0\n",
    "                    if (result.iloc[k]['userId'],result.iloc[j]['userId']) not in C:\n",
    "                        C[result.iloc[k]['userId'],result.iloc[j]['userId']]=0\n",
    "\n",
    "                    C[result.iloc[j]['userId'],result.iloc[k]['userId']]+=1\n",
    "                    C[result.iloc[k]['userId'],result.iloc[j]['userId']]+=1                   \n",
    "    W={}\n",
    "    for key in C:\n",
    "        Nu=N[key[0]]\n",
    "        Nv=N[key[1]]\n",
    "        W[key]=C[key]/(math.sqrt(Nu)*math.sqrt(Nv))\n",
    "    #提取出具有相同兴趣的每一对用户及他们的兴趣相似度\n",
    "    user1_lst=[]\n",
    "    user2_lst=[]\n",
    "    for key in W.keys():\n",
    "\n",
    "        user1_lst.append(key[0])\n",
    "        user2_lst.append(key[1])\n",
    "\n",
    "    df_W=pd.DataFrame({'user1':user1_lst,\n",
    "                       'user2':user2_lst,\n",
    "                       'relevance':list(W.values())})\n",
    "    df_W.columns=('user1','user2','relevance')\n",
    "    \n",
    "    return df_W"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68490a9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_W=users_relevance_matrix(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6e260a7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_W.to_csv('E:/推荐系统/代码/中间量/User_based-CF_movielens中等数据集（部分）.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "16d81971",
   "metadata": {},
   "outputs": [],
   "source": [
    "#评价指标\n",
    "def Recall_func(item1,item2):\n",
    "    return len( list(set(item1).intersection(set(item2))) )/len(item2)\n",
    "def Precision_func(item1,item2):\n",
    "    return len( list(set(item1).intersection(set(item2))) )/len(item1)\n",
    "def Coverage_func(item1,item2):\n",
    "    return len(item1)/len(train['movieId'].unique())\n",
    "def Popularity_func(item1,df_movie_popularity):\n",
    "    popularity=0\n",
    "    n=0\n",
    "    for item in item1:\n",
    "        popularity=popularity+df_movie_popularity[df_movie_popularity['movieId']==item]['popularity'].values\n",
    "        n+=1\n",
    "    return popularity/n\n",
    "\n",
    "#给定一个用户以及和他有相同兴趣的所有用户，找出前K个兴趣相似度最大的用户\n",
    "def findKUser(user2,relevance,K):\n",
    "    user2=np.array(user2)\n",
    "    relevance=np.array(relevance)\n",
    "    index=np.argsort(relevance)[-K:]\n",
    "    return user2[index],relevance[index]\n",
    "#给定对一个测试用户的推荐名单和该用户对名单上物品的感兴趣程度，挑选前K个最感兴趣的返回\n",
    "def get_K2_item1(rank,K2):\n",
    "    if len(rank.values())<=K2:\n",
    "        K2_item1=list(rank.keys())\n",
    "        \n",
    "    else:\n",
    "        rank_keys=list(rank.keys())\n",
    "        rank_values=list(rank.values())\n",
    "        index=list(np.argsort(rank_values)[-K2:])\n",
    "        K2_item1=[]\n",
    "        for i in range(len(index)):\n",
    "            K2_item1.append(rank_keys[index[i]])\n",
    "        \n",
    "    return K2_item1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3850440",
   "metadata": {},
   "source": [
    "预测部分：\n",
    "\n",
    "给定K1，K2："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bc27ae53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "覆盖率为0.039680\n",
      "召回率为0.203339\n",
      "准确率为0.125091\n",
      "平均流行度为91.546259\n",
      "____________\n",
      "运行时间为186.600016\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "Recall=0\n",
    "Precision=0\n",
    "Popularity=0\n",
    "N=1\n",
    "Item1=set()       #最终推荐物品名单\n",
    "Item2=set()       #测试集用户的行为名单\n",
    "K1=80              #K近邻\n",
    "K2=20             #每个用户的推荐数目\n",
    "'''\n",
    "对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "'''\n",
    "for user, result in test.groupby('userId'):\n",
    "    obj_user=user                #目标用户id\n",
    "    rank={}                      #用来存储推荐名单的字典\n",
    "    result=result.reset_index()  #result的movieId列即为item2\n",
    "    item2=list(result['movieId'])      #获取测试集的用户行为\n",
    "    \n",
    "\n",
    "    df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "    if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "        print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "        continue\n",
    "    else:\n",
    "        K_user,K_relevance=findKUser(df_W_obj_user['user2'],\n",
    "                                     df_W_obj_user['relevance'],K1)    #第一个参数是与目标用户具有相关兴趣的所有用户，第二个参数是对应的相关程度\n",
    "    \n",
    "    df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "    \n",
    "    index=0\n",
    "    for relevant_user in K_user:                              #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "        df_relevant_user=train[train['userId']==relevant_user]#获取这K个近邻用户的训练集数据\n",
    "        \n",
    "        for otherUser_item in df_relevant_user['movieId']:    #获取近邻用户的产生行为的物品\n",
    "            if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                continue\n",
    "            else:                                             #将该物品加入rank中，更新目标用户对该商品的兴趣度\n",
    "                if otherUser_item not in rank.keys():\n",
    "                    rank[otherUser_item]=0\n",
    "                rank[otherUser_item]+=K_relevance[index]*1\n",
    "        index+=1\n",
    "        \n",
    "    if len(rank.keys())==0:\n",
    "        print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "        continue\n",
    "        \n",
    "    item2=list(item2)\n",
    "    item1=get_K2_item1(rank,K2)\n",
    "    Item1=Item1.union(set(item1))\n",
    "    Item2=Item2.union(set(item2))\n",
    "    \n",
    "    popularity=Popularity_func(item1,df_movie_popularity)\n",
    "    recall=Recall_func(item1,item2)\n",
    "    precision=Precision_func(item1,item2)\n",
    "\n",
    "    \n",
    "    Popularity=(N-1)*Popularity/N + popularity/N\n",
    "    Recall=(N-1)*Recall/N + recall/N\n",
    "    Precision=(N-1)*Precision/N + precision/N\n",
    "    N+=1\n",
    "    \n",
    "Coverage=Coverage_func(Item1,Item2)   \n",
    "print(\"覆盖率为%f\"%Coverage)\n",
    "print(\"召回率为%f\"%Recall)  \n",
    "print(\"准确率为%f\"%Precision)\n",
    "print(\"平均流行度为%f\"%Popularity)\n",
    "end=time.time()\n",
    "print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "159a5aa6",
   "metadata": {},
   "source": [
    "给定K2，K1循环取不同数值：\n",
    "\n",
    "K1，K2是关键超参数\n",
    "\n",
    "用户之间的兴趣相似度是算法实现的重要信息，如何快速计算，如何更合理的定义兴趣相似度是关键问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "da50f87d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=5\n",
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=10\n",
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=20\n",
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=40\n",
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=80\n",
      "无法对用户41做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户304做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户307做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户426做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=160\n",
      "用时：831.859920秒\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "K2=100\n",
    "Result_dict={}\n",
    "for K1 in [5,10,20,40,80,160]:\n",
    "    Result_dict[K1]=[]\n",
    "    \n",
    "    Recall=0\n",
    "    Precision=0\n",
    "    Popularity=0\n",
    "    N=1\n",
    "    Item1=set()       #最终推荐物品名单\n",
    "    Item2=set()       #测试集用户的行为名单\n",
    "    for user, result in test.groupby('userId'):\n",
    "        '''\n",
    "        对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "        '''\n",
    "\n",
    "        obj_user=user       #目标用户id\n",
    "        rank={}             #用来存储推荐名单的字典\n",
    "        result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "        item2=result['movieId']        #获取测试集的用户行为\n",
    "\n",
    "\n",
    "        df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "        if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "            continue\n",
    "        else:\n",
    "            K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)\n",
    "\n",
    "        df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "\n",
    "        index=0\n",
    "        for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "            df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "\n",
    "            for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "                if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                    continue\n",
    "                else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                    if otherUser_item not in rank.keys():\n",
    "                        rank[otherUser_item]=0\n",
    "                    rank[otherUser_item]+=K_relevance[index]*1\n",
    "            index+=1\n",
    "\n",
    "        if len(rank.keys())==0:\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "            continue\n",
    "\n",
    "        #print(rank)  \n",
    "        #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "        item2=list(item2)\n",
    "        item1=list(rank.keys())\n",
    "        #改动\n",
    "        item1=get_K2_item1(rank,K2)  #在原始item1中，根据目标用户对item的不同感兴趣程度（rank的取值）来挑选前K个最感兴趣的\n",
    "        Item1=Item1.union(set(item1))\n",
    "        Item2=Item2.union(set(item2))\n",
    "\n",
    "        popularity=Popularity_func(item1,df_movie_popularity)    #根据最终的item1计算这个推荐名单的平均流行度\n",
    "        recall=Recall_func(item1,item2)\n",
    "        precision=Precision_func(item1,item2)\n",
    "\n",
    "        Popularity=(N-1)*Popularity/N+popularity/N\n",
    "        Recall=(N-1)*Recall/N+recall/N\n",
    "        Precision=(N-1)*Precision/N+precision/N\n",
    "        N+=1\n",
    "\n",
    "    Coverage=Coverage_func(Item1,Item2)   \n",
    "    \n",
    "    Result_dict[K1].append(Recall)\n",
    "    Result_dict[K1].append(Precision)\n",
    "    Result_dict[K1].append(Coverage)\n",
    "    Result_dict[K1].append(Popularity)\n",
    "    \n",
    "    print(\"K1=%d\"%K1)\n",
    "    \n",
    "end=time.time()\n",
    "print(\"用时：%f秒\"%(-start+end))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ac31e9a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "K2_100=Result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ce22cbcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#将不同K2取值得到的预测结果存储在Result_sum中汇总\n",
    "Result_sum={}\n",
    "for K2 in [25,50,75,100]:\n",
    "    for loc,index in enumerate(['Recall','Precision','Coverage','Popularity']):\n",
    "        if (K2,index) not in Result_sum:\n",
    "            Result_sum[(K2,index)]=[]\n",
    "        if K2==25:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_25.values())[j][loc])\n",
    "        if K2==50:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_50.values())[j][loc])\n",
    "        if K2==75:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_75.values())[j][loc])\n",
    "        if K2==100:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_100.values())[j][loc])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b8f4c82",
   "metadata": {},
   "source": [
    "结果的绘制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ab901f1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x21f001abcd0>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['font.sans-serif']=['SimHei']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Recall')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Recall\")\n",
    "    plt.title(\"Recall\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "168355bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x21f03af2430>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Precision')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Precision\")\n",
    "    plt.title(\"Precision\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9a75c838",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x21f03b6fa60>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAETCAYAAAA23nEoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABMPUlEQVR4nO3dd3yUVdbA8d+ZSa8QQg29SBUUUEBaQFGBAK67oqtr24Krvpbd1ddesKCrrq+r6+ra1rLWdS0UCxYi4IJSlA5SBCS00NL7nPePZxJCSJkkM5mQnO/nk09mnrn3eU4CMye3PPeKqmKMMca4gh2AMcaYxsESgjHGGMASgjHGGC9LCMYYYwBLCMYYY7wsIRhjjAEsIZhmTEQmiMiPIrJTRK4NdjzGBJvYfQimORKRlsBGYIr3+3fAZFXdGNTAjAkiayGY5moasExVv1XVTOAzYFyQYzImqCwhmOZqALCp3PNZwGwRudnbhbRJRCYCiMijIvI/pQVFZLOIJHkf3+4tv0NEppQrs11ExovIAhF5pdzxmSKS5q1zabnjfxSRPSLylYjMFpEHvMevFJFt3td+F7DfhjFASLADMCZIWgBppU9UdaeInAVcDgwC2gNfisgg4F3gbuBvInISsF9V07wJ40ygL9ARSBWRzqpa5D3tY8D1wCoAEekMjAZOAuKBlcBrIhIL3A90AG4FSlT1ThHpD/wRGAqEAitFZLaq7gvUL8U0b5YQTHNVBISXPhGR84E7gH+p6mHgsIh8A4xW1XdFpLuIRAATcRIEwFnAacBW7/MonA/1Hd7nj6jq4tJreJPOjcCfcLqn2npfKvZ+hQJhQIH3+HigO7De+zwS6A1YQjABYV1GprnagvNhW2qS93n5WRZa7vknwFjgXOA/3mMCPKiq7VS1HdCZcq0OYGn5C4rIaOB9YBtwRbmXPMBy79dQ4K/lzv9qufN3rHhOY/zJEoJprt4DzhKRk0WkLc4H/T3AJSLSQkT6AMOA0r/w3wV+DkSq6k7vsc+B6SISJyIdcFoKLaq55jDgW+BNnARU/ngO0E1Vx5brEvoSmCgi7bzdSquAfvX6qY2phnUZmWZJVX/0Duq+i9PV86CqPiMi4cBqIB/4dbkP5/8CbwB/K3eOj0RkCLAWKAGuU9UD1Vz2XZwxit3AO0C2d0xiJTAE2Csi2cAyYIaqrhWR+4ElOO/VJ1T1e//8Bow5nt2HYEyQicj1QJyqPiAioThdUi+q6odBDs00M9ZlZEzwfQX8TER244wv5ABfBDck0xxZC8EYYwxgLQRjjDFelhCMMcYAlhCMMcZ4nbDTThMTE7Vr167BDsMYY04oK1asOKCqrSt77YRNCF27dmX58uXBDsMYY04oIrKjqtesy8gYYwxgCcEYY4xXQBKCiLwoIktE5M4ayrUVke+8j0O8a8Sner9ODkRsxhhjKuf3MQTvMsJuVR0hIi+JSC9V3VxF8cdwlvQFGAi8qaq3+DsmY0zzUlRUxK5du8jPzw92KEETERFBx44dCQ0N9blOIAaVk3EW7gKYD4wCjksIIjIe5xb9vd5Dw4EUERkHrAGuUtXiAMRnjGnidu3aRWxsLF27dkVEgh1Og1NVDh48yK5du+jWrZvP9QLRZRTN0TXhD3F0E5AyIhIG3IWzO1SpZcBZqno6zkYhkyqpN0NElovI8vT0dL8HboxpGvLz82nVqlWzTAYAIkKrVq1q3UIKRELI5mg3UEwV17gV+LuqHil3bLWq7vE+Xg70qlhJVZ9T1aGqOrR160qn0dZIVcn97rs61TXGnDiaazIoVZefPxAJYQVONxE4e9Nur6TMWcC1IpIKnCIiL+DsLTtIRNzAeXj3ofW3I+++y45fXkzON98G4vTGGMMVV1zB4sWLyc7O5pRTTuGrr74iOTmZ8ePHM2PGDKpaVHTnzp3HlUtLS6Njx44kJyeTnJxMIHtHAjGG8AGwyLuD1ETgIhF5QFXLZhyp6pjSxyKSqqq/FZEBOBuQCDBbVT8PQGzEp6Rw8B/Psfe+++j+/ntIWFggLmOMMVxzzTVcd911zJ8/n2eeeYa+ffsyceJE1qxZw1133UVGRkZZ2YsvvpgdO3YcV27Lli3ccccdXH311QGP1+8JQVUzRSQZmICzyfheqvlrX1WTvd/X4sw0CihXZCTt7rqTn676PQf/+TKJV80I9CWNMUE0c8461u/O9Os5+3WI454p/ast8/LLL5Odnc1vfvObY44fPHiQxMREPvyw+v2PSsv961//4osvvuD555/n3HPPZdasWfWOvyoBuQ9BVQ+r6jveZNDoxIwdS+yECRx45hkKd+0KdjjGmCZowYIFbNmyBY/HU3bs7bffpn///nTo0KHauuXLTZw4kdTUVJYtW8aSJUtYvXp1wGI+Ydcyqq+2t99G9uSv2Xf/A3R89plmPwBlTFNV01/ygfL000/z+uuv8/rrr3PppZeybds2HnvsMT7/3OkNnzZt2nFdRjNmzDiu3BlnnEF4eDgAp556Kps3b2bgwMB0pjTbhBDavj2tr7uO/X/+M1mff07chAnBDskY04TExMRw7733MnnyZM4991x++ctf8tJLLxEfHw9QaZfR4cOHjyt3zjnn8OabbxIfH8/8+fO56qqrAhZzs17LKOHSXxHeuzf7HpyFJycn2OEYY5qYHj16MGbMGAYMGMDOnTu57rrrSE5O5quvvqq0/MMPP3xcuXvuuYdx48YxfPhwfv/739O7d++AxXvC7qk8dOhQ9cfy17krv2PHxReT8Otf0/Z/b/ZDZMaYYNuwYQN9+/YNdhhBV9nvQURWqOrQyso36xYCQNTgU2lxwS849Mor5G/6IdjhGGNM0DT7hADQ+o9/xB0Xx95770XLzQgwxpjmxBICENKyJW1uvpm8774j4733gh2OMcYEhSUEr/ifnUfk0CHsf/Qxig8fDnY4xhjT4CwheIkI7e+5h5KcHPY/9liwwzHGmAZnCaGc8F69aHXlFWT85z1yV6wIdjjGGNOgLCFUkHj11YR26MDee2eiRUXBDscYcwKq62qnla1sWlRUxJQpUxg5ciQvvfRSQONutncqV8UVFUXbO+9g1zXXcujVV2lVYWEqY8wJ5uNbYe8a/56z3ckw8eEai9V2tdPExMTjVjZ9/PHHGTJkCPfeey+TJk3iggsuIDY21r8/j5clhErEjh9PzPjxpD/9d1pceBHumOhgh2SMOcHUZbXT//3f/z1uZdPU1FQefthJPmPGjGH58uWMGzcuIDFbQqhCq9/+luwvvyTr889ocd55wQ7HGFNXPvwlHwgLFiwgOjoaj8eDy+X0zte02unEiRO56667iIqK4qyzzmL16tXk5OSQlJQEQEJCAvv27QtYzDaGUIXIU08htFMnMmfPCXYoxpgT0NNPP82gQYN4/fXXAcpWMX3iiScAZ7XT0rGC5ORknnvuOc444wxiY2Nxu91lK5vGxMSQl5cHQHZ29jHLafubtRCqICLET5nCgWefpWjffkLbtgl2SMaYE0hdVjtNTk4+bmXTIUOGsHjxYn7xi1+watUqhg8fHrCYA9JCEJEXRWSJiNxZQ7m2IvJdbevVx3f7v+N3839HTlHNq5vGTUkBj4fMefMCFY4xpgmr7Wqnla1sevnll3PPPfdwww03sH79eoYNGxa4gFXVr1/A+cDL3scvAb2qKfsasLG29VSVIUOGaF18v/97HfDyAH1rw1s+ld92wXTdOu28Ol3LGBMc69evD3YIfpWWlqZvv/22HjlypFb1Kvs9AMu1is/VQLQQkoF3vI/nA6MqKyQi44EcoHSbzRrricgMEVkuIsvT09PrFNzAxIH0TejLW5veqnIucHnxU6dSsHGjrYRqjAmaDh06MH369LLupkAJREKIBtK8jw8BbSsWEJEw4C7g1trUU9XnVHWoqg5t3bp1nYITEX7Z55dsObKF5ftq3k8hbtJECAkhc64NLhtjmrZAJIRsINL7OKaKa9wK/F1Vj9Synl9M7DaR+PB43tz4Zo1lQxISiBk1iow5c21pbGNMkxaID90VHO3uGQRsr6TMWcC1IpIKnCIiL/hYzy8iQiL4Wc+f8eXOL9mXU/Oc3vipUyjeu5fcb5cFKiRjjAm6QCSED4BLReRxYDqwTkQeKF9AVceoarKqJgPfq+pvK6kX0Kk903tPx6Me3t38bo1lY8aPxxUdTcbs2YEMyRjTRNR1LaN77rmn7L6EPn368NBDD1W6vlGg+P0+BFXNFJFkYALwiKruBVZVUz65inoZVdXxh06xnRjdcTT/3vRvZpw8g1B3aJVlXRERxJ5zDlmfforn7rtwRUQEMjRjTBNR27WMZs6cWfb8F7/4BZdddhnffPPNcesbBUpAbkxT1cMcnTEU8Hp1dVHvi7hm1zV8vvNzJnabWG3Z+KlTyHjvPbIXLCBuYvVljTGNx5+//TMbD2306zn7JPThltNvqbZMXdYyKrVs2TI6duxIUlISS5cuPW59o0Bp1ktXjEwaSafYTry18a0ay0adfjoh7dqR8aF1GxljarZgwQK2bNlyzFITNa1lVOqvf/0r1113HeCsb5SamsqyZctYsmQJq1evDljMzXrpCpe4uLD3hTy2/DE2HdpE74TeVZYVl4v4lMkcfPkVig8dIiQhoQEjNcbUVU1/yQfK008/zeuvv87rr7/OpZdeWraW0eeffw44axlV7DKaMWMGR44cYf/+/fTo0QOAM844g/DwcICy9Y0GDhwYkJibdQsB4Lye5xHhjvBpCmrclKlQXEzmRx83QGTGmBNZ6VpGDz74IOnp6ZWuZZSamlr2NWPGjLLjkyZNKjvPOeecw549e8jNzWX+/PkMGDAgYDE3+4QQHx7P5O6T+ejHj8goqH4cO6L3SYT36UPGHOs2MsbUrLZrGQF8+umnjBkzpux5ZesbBYr4snxDYzR06FBdvrzmO419sfHQRi6YcwE3D72Zy/pfVm3Zgy++xP5HH6XHJx8T1rWrX65vjPGvDRs20Ldv32CHEXSV/R5EZIWqDq2sfLNvIYAzY+CU1qfw9qa38Wj1dyPHpUwGETJsnwRjTBNjCcHrl31+yc6snSzZvaTacqFt2xI9YjgZc+b4tDieMcacKCwheE3oMoFWEa18Hlwu+ukn8r7/PvCBGWNMA7GE4BXqDuXnJ/2chbsWsitrV7VlYydMQCIibCkLY0yTYgmhnAtOugCXuHjnh+pvlnbHRBN75plkffQxWljYQNEZY0xgWUIop110O8Z3Hs97m98jvzi/2rLxU6dQkpFB9qJFDRSdMcYEliWECi7qfREZBRl8sv2TastFjxyJOyHBZhsZY45T19VOwZkqOm3atLLnRUVFTJkyhZEjR/LSSy9VecwfmvXSFZU5rd1p9IjvwZsb32Raj2mISKXlJCSEuMmTOfL225RkZuKOi2vgSI0xvtg7axYFG/y7uF143z60u/32GsvVdrXTM888k5tvvpns7Oyy40899RRDhgzh3nvvZdKkSVxwwQU8//zzxx2LjY2t989lCaECEeGiPhfx4DcPsubAGga2rnrNkPipUzn82mtkfvopLS+4oAGjNMY0dnVZ7XT//v385z//4Zxzzik7lpqaysMPPwzAmDFjWL58eaXHxo0bV++Yg5YQRCQBGAJ8p6oHghVHZab0mMITK5/grY1vVZsQIgb0J6xbNzJnz7GEYEwj5ctf8oGwYMECoqOj8Xg8uFxO73xNq522adPmuGM5OTkkJSUBkJCQwL59+yo95g8BGUMQkRdFZImI3FnF6y2BucDpwAIRaS0iISKyU0RSvV8nByI2X0SHRjOl+xQ+2f5JtesbiQjxU6eQu2wZRWlpDRihMaaxe/rppxk0aBCvv/46QNlqp0888QTgrHZaugtacnIyzz33XKXniYmJIS8vD4Ds7Gw8Hk+lx/zB7wlBRM4H3Ko6AuguIr0qKTYQ+KOqPgh8Cgz2HnuzdGtNVV3j79hq4/xe51PkKeKTH6sfXI6bMgWAjLkB3fHTGHOCqetqpxUNGTKExYsXA7Bq1Sq6du1a6TF/CESXUTJHdz2bD4wCNpcvoKpfAYjIGJxWwn3Ar4AUERkHrAGuUtXiAMTnkz4JfejVshezt87mwj4XVlkurGNHIocMIWP2bFrN+F2Vg9DGmOan/GqnLperbNObmTNnMnbsWJ/OcfnllzNp0iQWLVrE+vXrGTZsGElJSccd8wtV9esX8CIwyPv4bODWKsoJ8DTwIRAJnAa09772KjC1kjozgOXA8s6dO2ugvbz2ZR3w8gDdemRrteUOvfW2ru/dR3PXrg14TMaYmq1fvz7YIfhVWlqavv3223rkyJFqj1VU2e8BWK5VfH4HYgwh2/sBDxBDFd1S3tiuBVYDU4HVqrrH+/Jy4LiuJlV9TlWHqurQ1q1b+z/yCiZ3n4xb3MzeUv0SFXHnnoOEhpJp9yQYYwKgQ4cOTJ8+vay7qapj9RWIhLACp5sIYBCwvWIBEblFREo3HmgBHAFeE5FBIuIGzgNWBSC2WkmMTGRk0kjmbJtDiaekynLu+HhikseSMW8eWhy0Xi5jTDnazFcjrsvPH4iE8AFwqYg8DkwH1onIAxXKPOctsxBw44w13Ae8BnwPLFHVzwMQG+Rnwrr3wcdR+ak9prI/dz/f7P2m2nJxU6dScuAAOUuW+iNKY0w9REREcPDgwWabFFSVgwcPEhERUat6fh9UVtVMEUkGJgCPqOpeKvy1r6qHva+XtxZnplFgbfoI3r8KfvsFdKx006BjJHdKJjYsltlbZ3NGhzOqLBczdiyuuDgy5swmZvSoKssZYwKvY8eO7Nq1i/T09GCHEjQRERF07NixVnUCcmOa9wO/+iVDg+Wkc8EVCus/8CkhhLvDmdh1IrO3ziZ7WDYxYTGVlnOFhRF37rlkzJmDJycHV3S0nwM3xvgqNDSUbt26BTuME07zW9wusgX0GAfrPwQfm5NTe04lvySfz3Z8Vm25+GlT0bw8sr74wg+BGmNMw2p+CQGg3zQ4shP2fO9T8YGJA+ka15UPtnxQbbnIU08lNCnJVkA1xpyQmmdC6D0JXCFOK8EHIsLUHlNZuX8lP2X9VHU5l4u4qVPI+e9/Kdq/31/RGmNMg2ieCSEqAbqNqVW30ZQeUxCEOVur/+s/fsoU8HjI/Ogjf0RqjDENpnkmBHC6jQ5tg31rfSreLrodw9oPY/bW2Xi06imr4d27EzFggO23bIw54TTfhNAnBcTlc7cROPckpGWnsXLfymrLxU+dSsH6DRRs3lxtOWOMaUyab0KIToSuo2DdBz53G53Z+UyiQqKYvbWGpSwmTwK3m4w5c/0QqDHGNIzmmxDA6TY6uBnSfdteLyo0irO7ns38HfPJLcqtslxIq1ZEjxpJxtw5qJ/WKTfGmEBr3gmhzxRAat1tlFOUwxc7q7/XIH7KVIp37yF3+fJ6BmmMMQ2jeSeE2LbQ5YxaJYQhbYeQFJNUY7dR7JnjcUVF2eCyMeaE0bwTAjjdRvvXQ/oPPhV3iYspPabwzZ5v2Juzt+pykZHEnn02WZ98iqegwF/RGmNMwFhC6OtsgcmGWnQbdZ+KoszdVv2gcfzUKXiys8lekFqPAI0xpmFYQojrAB1Pr1W3Uae4TgxuM5gPt3xY7fK6UcOGEdKmjXUbGWNOCJYQwOk22rvGuVHNR9N6TmN75nbWHFhTZRlxu4lLSSF74UKKDx/2R6TGGBMwlhAA+k11vq/3/S/5s7ucTYQ7osbB5fipU6C4mMyPP65PhMYYE3BBSwgikiAiE0QkMVgxlGnRGToMrlW3UUxYDOM7j+ejHz+ioKTqQeOIPn0IP+kk22/ZGNPoBSQhiMiLIrJERO6s4vWWwFzgdGCBiLT2pV5A9ZsGu1c6y2L7aFqPaWQVZpH6U2q15eKnTiHv++8p3On7uY0xpqH5PSGIyPmAW1VHAN1FpFclxQYCf1TVB4FPgcE+1gucOnQbDWs/jDZRbWpeyiIlBUQ48t579YnQGGMCKhAthGSObp85Hzhug2FV/UpVl4rIGJxWwhJf6onIDBFZLiLL/b5XakJ3aDewVt1GbpebKd2n8HXa1xzIO1BludB27Yg9+2wOvfRPCrZu9Ue0xhjjd4FICNFAmvfxIaBtZYVERIALgcNAkS/1VPU5VR2qqkNbt27t77idbqNd30JGWs1lvab2nEqJljBv27xqy7W7605cUVHsvu12tLi4vpEaY4zfBSIhZAOR3scxVV1DHdcCq4GpvtYLqH7nOd83+D4A3D2+Oycnnlxjt1FIYiLt7r6L/NWrOfjSP+sRpDHGBEYgPnRXcLS7ZxCwvWIBEblFRC7zPm0BHPGlXsAl9oQ2/WvVbQTOgnc/HP6BjYeqXzU1duJEYs85hwNPPUX+D74tlWGMMQ0lEAnhA+BSEXkcmA6sE5EHKpR5zltmIeDGGTOoWK/6PphA6TcNdi6BrKrXKapoYreJhLpC+XBL9YlERGh3z924YmPZc9vtaFFRfaM1xhi/8XtCUNVMnAHipcA4VV2lqndWKHNYVSeo6hhVvcbbfVSxXoa/Y/NJv2mA1qrbKD48nuROyXz040cUear/kA9JSKDdPfeQv24dB55/vp7BGmOM/wSkn977gf+Oqvr+Z3Y96vlVmz6Q2LtO3UaH8g+xeNfiGsvGnXM2cZMnc+Dvz5C/YUNdIzXGGL+ypSsq028a7Pgasn2f2joyaSQJEQk1Di6XanvnHbhbtHBmHRUW1jVSY4zxG0sIlek3FdQDG33fEznUFcrk7pNJ3ZXKkfwjNZYPadmS9vfNpGDjRg48+496BGuMMf5hCaEybQc4N6ptqN2y1dN6TKPYU8zH231byC52/Hjip03jwD/+Qd66dXWJ1Bhj/MYSQmVEnHsStn0FGbt8rtY7oTe9W/Zm9hbfE0nb228jpFUr9tx6Kx7rOjLGBJHPCUFEBojIOSLSV0RiAhlUozDkCkBh2Qu1qja1x1TWHlzL1iO+LVHhjo+n/f33UbB5Cwf+9nTt4zTGGD/xKSGIyFPATOAhoDvwRiCDahRadoE+KbD8n1CY63O1Sd0n4RY3H26txVLaY8cS//PzOfjCC+StXl2XaI0xpt58bSGcrKo/B46o6jwgPoAxNR7Dr4H8I7D6LZ+rJEYmMippFPO2zqPEU+Jzvba33kpI27bsvvU2PAVV769gjDGB4mtCSBeRu4GWInI5ELz7BBpS5+HQ4VRY+gx4PD5Xm9ZzGvvz9rN0z1Kf67hjY2n/wP0UbttG+pNP1iVaY4ypF18TwmVABs4y1fHAlQGLqDERcVoJB36AbV/6XG1sx7HEhcXVqtsIIGbkSFpceCGHXvonuSu/q220xhhTL74mhBtU9a/eZSaeBLp69zJo+vqdBzHtnFaCj8LcYUzsNpEvd35JVmFWrS7X5uabCW3fnj233YYnL6+WwRpjTN35PIYgIktF5CLv87uAmwIUU+MSEgan/xa2fA7pm3yuNq3HNApKCpi/fX6tLueOiab9rAcp3LGD9CeeqGWwxhhTd74mhO44S1Nf533eBggNSESN0ZArISQCvnnW5yoDEgfQLb5brbuNAKKHD6flxRdz6NXXyF22rNb1jTGmLnxNCIeBp4EIEZkGnERzSgjRiTBwOnz/JuQe8qmKiDC1x1S+2/8dOzN31vqSbW76E6EdO7L79jvw5Po+7dUYY+rK14RwPvAMcC4QB0wEfJ+L2RQMuxqK82DlKz5XSemegiA+L3hXnisqig4PzaJo1y72P/aXWtc3xpja8ikhqGo+zn7HkcBXQKyq1u4W3hNd237QPRm+fR5KfNvYpl10O0Z0GMGcrXPwqO/TVktFDR1KwmWXcviNN8hZ6vsUVmOMqQtf71R+EXgb+BB4E3i0pvIiskRE7qzi9XgR+VhE5ovI+yISJiIhIrJTRFK9XyfX9ocJuOHXQGZarRa9m9pjKrtzdrNi34o6XbL1jTcS1qULe26/g5LsnDqdwxhjfOFrl1FPnO6iLcBYoMo/d0XkfMCtqiOA7iLSq5JilwCPq+rZODe5nQsMBN5U1WTv15pa/BwNo+cESOhRqymo4zuPJzo0usbtNaviioyk/UMPUbR3L/sfrTYPG2NMvfiaEHKBM3H2P74AaFlN2WTgHe/j+Tizk46hqn9X1c+8T1sD+4HhQIqIfOttYYRUrCciM0RkuYgsT0/3ffOa8vIKS/hs/T5UtfaVXS4YfjXsWgY/+Tb7JzIkknO6nsP8HfPJLarb4HDU4FNJuPIKjrz9NtmLv67TOYwxpia+JoRfAJuBPwB9gWuqKRuNM94AcAhoW1VBERkBtFTVpcAy4CxVPR1nBtOkiuVV9TlVHaqqQ1u3bu1j6Meau3o3v3t1Oat21XHL5kG/hPB4+Mb3VsLUHlPJK87j852f1+2aQOvrryese3f23HknJVm1u9nNGGN84eugco6qblHVHap6t6ouqqZ4Ns7gM0BMVdcQkQTgKeDX3kOrVXWP9/FyoLKupno7u187Qt3CR2v21Fy4MuExMOQyWPcBZKTVWBxgcJvBdIvvxl9X/pX03Lq1bFzh4XR4+CGK9+9n38MP1+kcxhhTHV8HlX3bAsyxgqPdRIOA7ZWcLwz4N3Cbqu7wHn5NRAaJiBs4D1hVi2v6LD4qlJE9E5m3ek/duo0ATp+Bs1fC8z4VFxEeHfMoWYVZ/CH1DxSW1G0jnMiBA2n129+S8Z/3yP7qqzqdwxhjquJrl9Ea7w1pvvgAuFREHgemA+tE5IEKZX4DDAbu8M4ouhC4D3gN+B5Yoqp171+pwaST25N2JI/Vde02atEZ+k6p1V4JvRN68+CoB1mVvooHlj5Q52SU+D/XEt6rF3vuupuSjDrGb4wxlfA1IZwGvOUd8F0gIlUu/amqmTgDy0uBcaq6SlXvrFDmGVVtWW5G0duqulZVB6rqyap6R11/IF+c3a8tIa56dBtBnfZKmNBlAlcNvIr3t7zPGxvrtseQKyyM9g8/RPHBg+yb9VCdzmGMMZXxdQxhnKpGqurp3sfjayh/WFXfUdVGuW9Ci6gwp9toTT26jToNq9NeCdeccg3jO43n0WWP1mq/hPIi+/cn8aqryPjwQ7K+9H1ZbmOMqU6z3VN58snt2XU4jzVpdex2qeNeCS5xMWv0LLrFd+Omr27ip6yf6nT5xN9fRXifPuy5+x6KDx+u0zmMMaa8Zrun8tn9nW6jefXpNirdK2HJ32tVLTo0mifHObuiXf/l9eQU1f4OZAkLo8PDD1Fy5Aj7Hniw1vWNMaaiZruncouoMM7omchH9ek2Kt0rYesXsH9jrap2iuvEY2Mf48eMH7l90e11Wusook8fEq+5msx588j8tHb7LhhjTEXNek/lySe346dDeaxNy6z7SeqwV0Kp4e2Hc9PQm/jypy95ZpXvN7qVl/i73xHRvz97Z86k+JBvS3MbY0xlmvWeymf3a4e7vt1GpXslrHrL570Syruk7yWc1/M8nl31LJ/t+KzmChVIaCjtH5qFJyuLvTPvq3trxxjT7PmaECYBz5XuqayqTWLHlpbRYZzRo1X9uo3g6F4JK16udVUR4a7hdzGw9UDuWHwHmw75vk1nqYiTTiLxuuvI+vRTsj6uzT2ExhhzlK8JoRfwHxF5XUQuFJHoQAbVkCaf3J6dh3JZt7se3UZ12CuhvDB3GE8kP0FsWCw3LLiBw/m1nzXU6tdXEjFwIHtn3kdxHRf+M8Y0b77eh/Cwqk4Cfo+zfeaOGqqcMM7u74duI3CmoGbthvV1W+a6dVRr/jrOWevoT1/9iSJP7RKLhITQ4aFZePLy2HPvTOs6MsbUmq/TTqeKyLM4000FGB3QqBpQgr+6jeqwV0JFAxIHcO8Z97Js7zIe+faRWtcP79GD1jfeSPYXX5A5d26d4zDGNE++dhkNAB5T1Smqep+qbghkUA1t0snt2XGwnt1GpXslpC33ea+EykzpMYUr+l/BW5ve4t0f3q11/YTLLyPy1FPZe/8DFO3bX+c4jDHNj68J4VFgvIj8n4j8trLNa05k53i7jeq1thEc3Sthae1uVKvoxsE3MjJpJA9+8yAr962sVV1xu2k/60G0sJC9d99tXUfGGJ/5mhBeAtoDnwBJwD8DFlEQJESHMaK7H7qNSvdKWP8hZOyq82ncLjePjHmEpJgk/pD6B/Zk1y5RhXfrRps//oHsr74i4/0P6hyHMaZ58TUhdFLVmar6qarOBDoFMqhgmHRye7YfzGX9nnp0G8HRvRK+9W2vhKrEhcXx5PgnKSwp5IYFN5BXnFer+i1/9Suihg5l36xZFO1tEvcRGmMCzNeEsFtEbhOR8SJyB7A7kEEFwzn92/qn26h0r4QVL0Nh7dcoKq97fHf+PObPbDy0kbu/rl33j7hctH9oFurxsOfOu6zryBhTo2oTgohEiciNwFtAJjDX+/2qwIfWsFrFhDO8ewIfrdlb/w/P0r0SVvm+V0JVxnQcww2Db+CT7Z/w4toXa1U3rFMn2tz0J3IWL+bIv/9d71iMMU1bTS2E14B8nP2On8bZ+Cbce7xKIvKiiCwRkTureD1eRD4Wkfki8r53S80a6wXapJPb8+OBHDbsqecm9qV7JXzzbK32SqjKrwf8mondJvLkyif56qfabZ3Z8qKLiBo+nP0P/5miNN/2gDbGNE81JYR2qvqsqm4HUNVvVfUxoHVVFUTkfMCtqiOA7iLSq5JilwCPq+rZOAvlnetjvYA6p387XEL9u43K75Wwtf4b2IgIM8+YSZ+EPtyy6Ba2Hdnme12Xi/YPODuY7r7jTtQPCcoY0zTVlBC+EJEvReQmEfm1iFwvInOA5dXUSQbe8T6eD4yqWEBV/66qpSu5tQb2+1Iv0BJjwhnuj9lGcHSvhHpOQS0VGRLJk+OfJNwdzvULriejwPeNfcI6JtHmllvIXbqUI2+/7Zd4jDFNT7UJQVXvBu4AYnD2VU4CnlfVG6qpFg2U9k0cAtpWVVBERgAtVXWpL/VEZIaILBeR5ekBWq9n0snt2XYgh41769ltVI+9EqrSLrodT4x7grTsNG5ZeAslnhKf67aYfgHRI0ey79HHKPypbru0GWOathpnGanqElW9V1WvVtVbVHV2DVWygUjv45iqriEiCcBTwK99raeqz6nqUFUd2rp1lb1W9XLuAD91G0G99kqoyqltTuXOYXfy9e6v+b8V/+dzPRGh/QP3Iy4Xe26/w7qOjDHH8XlP5VpYwdHunkHA9ooFvIPI/wZuU9UdvtZrCIkx4Qzr1op5/ug2qudeCVX5+Uk/55d9fskr619hztY5PtcLbd+etrfdRu6yZRz+1+t+i8cY0zQEIiF8AFwqIo8D04F1IvJAhTK/AQYDd4hIqohcWEm9eQGIzSeTBrZnW3oOm/bVs9sI6rVXQnVuPu1mTm93Ovf+917WpK/xuV78+T8jeuwY9j/+OIXbt/s1JmPMic3vCUFVM3EGiJcC41R1lareWaHMM6raUlWTvV9vV1LP91FTPzu3dLbRaj90G9Vzr4SqhLpCeWzsY7SOas2NC24kPde3MRURof199yNhYey+/Q60xPdxCGNM0xaIFgKqelhV31HVWq2ZUNd6/tY6NpzTuyUw1x/dRnB0r4R1H9T/XOW0jGjJk+OfJKsoixsX3EhBSYFP9ULbtqHdnXeQt3Ilh16t9pYSY0wzEpCE0BRMH9qJbek5zF7lh1U6ek6ANv1g3h/rtTR2ZU5qeRKzRs1i9YHV3L/kfp8TWNyUKcSceSbpTzxBwTbf72swxjRdlhCqcN4pSQxIiuPhjzeSW1hcv5O5XHDJv51B5td+BjuX+idIr7O6nMXVg67mw60f8q8N//KpjojQ/t57cEVEsPu229Diev6MxpgTniWEKrhcwt0p/dmTkc8/vvLDX9DxHeGKjyC2Hbx2PmxfXP9zlvP7Qb/nzM5n8tjyx1iye4lPdUJat6bt3XeRv2o16X/7G1pY6NeYjDEnFksI1Ti9WwKTB7bnHwu3svtI7ZafrlRce7hiHrToBP/6BWxLrf85vVziYtaoWXSP785NX93EzsydvoU0aRJxkyZy8Nl/8MPoMey5625yvv3W7lMwphmyhFCD2yb2QRUe/tg/dxsT2xYunwsJ3eGNC2HL5/45LxAVGsWT459ERLj+y+vJLsyusY6I0OGRR+j03D+IGTOGjHnz2HnZ5WwZN559jzxK/vr1tnS2Mc2EnKhv9qFDh+ry5dUtqeQ/f5m/iae+3MJ/rh7BkC4J/jlpzkF4bRqkb4ILX4eTzvbPeYFv9nzDVZ9dxeik0fx1/F9xie9535ObS9aCBWTOnUf2okVQXExYjx7Ep0wmbvJkwjp39lucxpiGJyIrVHVopa9ZQqhZTkEx4/+SSru4CN6/ZiQul/jnxLmHnEHmfetg+qvQZ5J/zgu8vuF1Hv72YWYMnMF1p15Xp3MUHz5M1qfzyZw7l1zv7zpi0EDiU6YQN/FcQhIT/RavMaZhVJcQrMvIB9HhIfzvOX1YtSuD97/z454CUQlw2YfQfiC8cymsr2mZKN9d3Odizu91Ps+tfo5Pt39ap3OEtGxJy4supMu/XqPnl1/Q5qY/oQWF7HvwQTaPGcvO3/yWIx98QEl2zV1TxpjGz1oIPvJ4lJ8981/2HMljwU3JRIeH+O/k+Rnw+gWwazn8/AUYcL5fTltYUshvPv0Nmw5v4tWJr9InoY9fzluweTMZc+eROXcuRWlpSHg4MePGEZ8ymegxY3CFhfnlOsYY/7MuIz9ZseMwP3/mv/zPuJ7cdE5v/568IAtenw4/LYWfPQcDL/DLaQ/kHeCiuRfhEhdvpbxFQoSfxkAAVSXv++/JnDuPzI8/puTQIVxxccSdczZxk1OIOm0o4nb77XrGmPqzhOBHN7z1HR+v3csXfxxLp4Qo/568MMeZebTja5j2NJxysV9Ou+7AOi7/5HIGJA7g+QnPE+oO9ct5y9OiInKWLiVz7lyyPvscT24uIW3bOtNaUyYT0a8fIn4aezHG1JklBD/afSSP8X9J5cw+bXn6ksH+v0BhLrx1sXOPwtQnYfBlfjntvG3zuHXRrUw/aTp3jbjLL+esiicvj+zUVDLmzHVmKhUVEdatG3FTUoifPJmwLl0Cen1jTNVsUNmPOrSI5PdjezBvzR6+2XbQ/xcIi4JfvgU9z4TZ18GyF/1y2sndJ3PlgCt554d3eGfTOzVXqAdXZCRxEyfS6e9Pc9KihbS7byYhrVtz4Km/sfWcc/lx+oUcevVVigO0650xpm6shVAHeYUlnPmXVFpGhzH7f0bh9tc01PKKC+Cdy+CHT2DiozBsRr1PWeIp4X++/B+W7l7K82c/z9B2lf6REDBFe/aQ+dHHZMybS8H6DeByET18OHEpKcROOAt3bGyDxmNMc2RdRgHw4fdp3PDW9zzy84FMP61TYC5SXAjvXgkb58I5s2DEtfU+ZWZhJpfMu4SMggzeSnmLDjEd/BBo7RVs3UrG3Llkzp1H0U8/IWFhxCQnEzclhZgxY3CFhwclLmOaOksIAaCq/PyZ/7LzUB4LbhpLbIT/B2oBZ1Od//wW1n8AZ82EUTfW+5Q/ZvzIJfMuISk2iVfOfYWoUD8PjteCqpK/ejUZc+Y6M5UOHsQVG0vs2ROIT0kh6vTTbaaSMX7U4GMIIvKiiCwRkTurKdNWRBaVex4iIju9W2qmisjJgYjNX0SEe6b050B2AU8v2Bq4C7lD4ecvwoBfwOf3wMJH633KbvHd+POYP7Pp0Cbu+vquoK5VJCJEDhpEuzvvoNdXqXR64QVizzyTrE8+ZeeVv2ZL8jj2PfQweWvW2ppKxgSY3xOCiJwPuFV1BNBdRHpVUqYl8AoQXe7wQODNcttq+r5RcJAM6tSC8wcn8dLiH9lxMCdwF3KHwPnPwcCL4MsHIPVhqOeH4+iOo7lxyI3M3zGf59c876dA60dCQogZNZIODz9Er68Xk/TE/xExaCCH33iD7RdcwLaJk0j/29O2F7QxARKIFkIyUDqNZT4wqpIyJcCFQGa5Y8OBFBH51tvCOO5WYBGZISLLRWR5eiOZoXLLuX0IcQuzPtoQ2Au53HDe3+GUX0HqQ05iqGdSuLL/lUzuPpmnvnuKT7Z/0qj+AndFRBB37rl0+tvf6LV4Ee0fuJ+Qtm058PTTbD13Ij/+4gIOvfIKRfv3BztUY5oMv48hiMiLwJOqukpEzgYGq+rDVZRNVdVk7+PTgF2qukdEXgXeVdUqF/cJ9hhCeX/7cjOPzf+BN343jDN6BHjBN48H5v0BVrwMZ1wPE+6DetzwlV+czxWfXMG6g+toF92O0UmjGdNxDKe3Oz2oYwtVKdq3j8yPPiZzzhzy168Hl4uoYacTn5JC7Nln20wlY2rQoIPKIvJXnK6fpd7uoz6qOquKsuUTQriqFngfXw+EqupfqrpOY0oI+UUlnPmXr4iNCGHe9aMDMw21PI8HPr4Zlr0Aw69xZiDVIylkF2Yzf8d8Fu5ayJLdS8gtziXMFcZp7U9jTNIYRnccTafYAM2kqoeCbdvInDuPjLlzKdq505mpNHYscSkpxCSPtZlKxlSioRPCZUAbVX1MRGYCm1T1jSrKlk8I7wAPAmuBz4BZqlrl7jGNKSEAzFu9h2vfWMmDPxvAJcMa4E5cVfjkNvjmGTh9Bkx8pF5JoVRhSSEr9q1g4a6FLEpbxI7MHYAzED0maQxjOo7h1LanEuoK0KyqOlBV8tescaaxfvQxJQcO4IqJIfbss4lPmUzUsGE2U8kYr4ZOCHHAIuALYCJwEXCBqh4346hCQhgAvAEIMFtV76juOo0tIagqF/5jKVvSs1lwUzLxkQ3wgakKn90F/30KhlwJkx8Hl3+HhXZk7mDRrkUs3LWQ5fuWU+QpIiY0hhEdRjA6aTSjO44mMbLx7IugxcXkfvstGXPmkjV/Pp6cHNytE4mfNIm4lBQiBgywNZVMs9bg9yF4ZxFNABaq6l6/X4DGlxAA1qZlMOVvi/ntqG7cMblfw1xUFb68Hxb9BU69FKY86fekUCq3KJcle5awaNciFu1axP48Z0C3f6v+jOnotB76tepXqx3aAsmTn0/2VwvJnDuX7NRUtKiI0C6diZ+cQlxKCuHduwU7RGManN2Y1oBueXc17323i/l/GEu3xOiaK/iDqjMV9auHYdAvnZVSXYHtIlFVNh3exMJdC1m4ayGr01ejKAkRCYxKGsWYjmM4o8MZxIY1jkHeksxMsj77jIy5c8ld+g2oEtG/P3EpKcRNmkho27bBDtGYBmEJoQGlZxUw7rFUhndP4IXLT2vYi3/1KCx4AE6+AM571rl/oYEczj/M4rTFLNq1iMW7F5NVmEWIhHBq21PLxh66xXdrFN01Rfv2k/XJx2TMmUv+2rUgQtSwYcSnTHZmKsXFBTtEYwLGEkIDeyZ1K3/+ZCOv/eZ0Rvdq3bAXX/x/8Pm90P9ncP7zzp3ODazYU8zq9NVO6yFtIZsPbwYgKSbp6LTW9qcT7g7+LKCCH38kc95HZM6ZQ+GOHUhoKNFjxxCfMsWZqRQREewQjfErSwgNrKC4hAmPLyQi1MVH148mxN3Afer//RvMvwP6pMAv/gkhwd3Sck/2HhalOQPT3+z5hvySfCLcEQxrP4wxHccwOmk07WPaBzVGVSV/7Toy584l86OPKE5PxxUdTeyECcSlpBA9fBgS0nAtLmMCxRJCEHyydi+//9cK7pvWn8tGdG34AJY+C5/cAidNhOmvQEjw/xoH50a45fuWl409pGWnAdCrZa+y1sOg1oMIcQXvw1dLSpyZSnPnkjX/MzxZWbgTE4mbOJH4lMlEDBzYKLq+jKkLSwhBoKpc/Pw3bNibSepNybSICsJf6ctegHl/gl5nw/TXILRxdX+oKj9m/Fh2z8PKfSsp1mLiwuIY2WEkozuOZlTSKFpGtAxajJ6CArIXLiRzjnemUmEhoZ07E58y2TtTqXvQYjOmLiwhBMmGPZlMfnIRl43oyr1T+wcniBWvwJwboMc4uOgNCI0MThw+yCrMYsnuJWUJ4lD+IQRhYOuBZa2HPgl9gvbXeUlWFlmffU7m3LnkLF0KHg/hffsS3q0brugoXFHRuKIrflVxPCoSCdD0YGOqYwkhiG5/fw1vL/uJT28cTc82QZqC+f0b8ME10G20sz1nWANNh60Hj3pYf3C9kxx2LWLtwbUAtIlsw+iOzg1xI9qPCNp6S8Xp6WR+/DFZ8z+jOD2dktwcPDm5aG6uz+eQqChc0VG4KyaMqKhKEktlx73PoyzBGN9ZQgiig9kFJD+WypAuLXn5ytODF8jqd+D9q6DzCLj4HQiPCV4sdXAg7wCL0xaXrbeUXZRNqCuUoW2HMrqj03roEtcAS4bUQD0ePLl5eHJyjv3KzT3+WCXHncTiJBdPbi0SjAiuyMg6JJajj93R0UhUVNl3GydpmiwhBNkLi7bxwLwNPHPJYCaeHMTZNGv/A//5HXQ8DS75N0ScmPPtizxFfLfvu7KupW0Z2wDoEtelrGtpaNuhhAZhyq2/aUkJnryKCSYXT24lyaXc8ZLyx8olHs3L8+3CIscmjhqTS+WJpfSYREZagmkkLCEEWWGxhylPLWbTviwuGNKRWyb2ITEmSLN+1n8I7/4aOpwKl7wLkS2CE4cf/ZT1k7PeUtpClu1ZRqGnkKiQqGPWW2oT1SbYYTYKWlJybKukhpZLScWEU6GO5uf7dmGXy0keVSWWsrGWYxNLVclIIiIswdSRJYRGIKegmCe/3MxLi38kItTNnyacxK+Gd2n4exQANs6Ddy6HdgPgV+9BVELDxxAguUW5fLv327Jprfty9wHQN6FvWdfSgFYDcAd4aY/mQouLjyaISpJLSU4OmptbeWKppI4WFPh24dIEU2WrxbfEUpZgwsObTYKxhNCIbNmfzcw561i0+QB92sVy37QBnN4tCB/IP3wKb/8KWveGy2Y3qaRQSlXZfGRz2cD09+nf41EPLcNbMjJpZNl6S/Hh8cEO1XhpcXHlYyuVJpDcSls1xySYwkLfLux2Vz5oX67V4j4u6VTdhdaYE4wlhEZGVfl03V7un7uBtCN5/OzUJG6b2Ic2cQ18n8CWz+GtSyChB1w+G6IbzzLWgZBRkMHXaV+zKG0Ri9MWc6TgCG5xM6j1oLLVWnu26Nlo38im9rSoyIfkUkm3WRVdaVpU5NuF3W6/JJayFkxYmN/+X1pCaKTyCkt4esEWnlu4jbAQFzee1YvLz+hKaEN2I21LhTcucu5P6DQMkgZDh8HO9ybYaihV4ilhzYE1ZQPTGw9tBKB9dPtj1luKDGm8922YhqeFhZWMr5QO5vs2k6z8cZ8TTEhIueQSRcvp00m47LI6/QyWEBq57QdymDlnHQs2pdOrTQwzp/UP/N7M5f20DJa/CGkr4cAPgPf/RIsuxyaI9oMgvHEsZ+1v+3L2HZ3WumcJecV5hLvDOa3daWWth6SYpGCHaZoYLSz0JhbfB/o9OTnEnDmeFuedV6drBmODnBeBfsA8VX2gijJtgXdVdXRt6pVqSgkBnG6kLzbsZ+bcdfx0KI+Uge25Y3Jf2sc38F+o+ZmwZxXsXukkiN0r4chO74vijDmUJogOg52B6UayTpK/FJYUsnzf8rKd4nZmOT9/j/geZQPTp7Q5pVFtI2qMrxp6C83zgamqeoWIvAQ8pKqbK5RpCbyJs/fyYF/rldfUEkKp/KISnv1qK8+kbsXtEq4b34vfjOpGWEgQ70LNOXA0OZR+z0l3XnOFOkmhfJJo3TvgG/Q0pO0Z28tWa12+bznFnmJiQ2Odaa0dR5MUk0RkSORxX+HuxjuwaJqvhk4ITwKfqOpHInIREKmq/6xQJg5n7+QPy+2pXGO98ppqQij106Fc7pu7ns/W76N7YjT3Tu3PmJMaeG+FqqhCxq5jE8Tu76Eg03k9NNrpXkoa7NzvkDQYWnaDJvDhmFOUw9LdS1mY5sxcSs9Lr7KsIMcmidDjk0ZUSFSlyaSmOhEhEY1mq1JzYqkuIQRijeFoIM37+BAwuGIBVc30BlareiIyA5gB0LlzZ78F3Bh1Soji+cuGsmDTfmbOXsdlL33Luf3bcWdKXzq2DM76PWVEoEUn56vfNOeYxwOHtpZrSaxwVlst9t64FNnSSQ4dBkPSECdJxLYL3s9QR9Gh0ZzZ5UzO7HImqsrWI1s5XHCYvOI8cotzySvKI6+45q+MggzncbnyxVpcq1gi3BE+JZDKvsoSURXlg7n8uAmeQPyrZwOlHd8xgK9/xtRYT1WfA54Dp4VQvzBPDON6t+GMP7TihUU/8tSXm0l9fD/XJvfkd2O6ExHaiLplXC5I7OV8DbrQOVZSBPvXl0sS3zk7ummJ83psh2NbER1OdRLHCUJE6Nmyp9/OV1RS5CSVcokjtyjXpwRTPiGl56Yf91qRx8fZLF6hrtAqWyw1tmoqSVDl64S6Qq0rrZEKREJYAYwClgKDgE0BrtfkhYe4uXZcT847NYkH563nL5/9wLsrd3HvlP6M69OIl2RwhzpdR+0HAVc6xwpzYe+aY7ubNs49Wieh+7HjEe0HnhCrs/pDqDuUeHd8QG6UK/YUV55IisolE19aNvkZ7C3ee8yx/BIfl6/wcou71t1k1XavlSsf4bYlLeojEGMIccAi4AtgInARcIGq3llJ2dRyYwgV6w1X1YyqrtPUxxCqs2hzOvfMXse29BzO6tuGu1P607lVkLuR6iPvCOz+rlyS+A4yvb2H4oLWfSHp1KOJok3/oG8Lao7yqIf84vzKk0oNXWi+1FF8/4wShIiQiOoTiY/damV1Q48mm6aw5Ekwpp22BCYAC1V1byDqNeeEAM6Cef/8+kf++sVmij3K78f24JrkHo2rG6k+svYd24pIWwl5h5zX3OHQ7uRj75Fo1cvptjJNiqpSUFJQYzeZr91q9R23CXeH17mrrKayDTWN2W5Ma8L2ZuQz66MNzF61m44tI7k7pR8T+rVtes1mVTiy49jxiD3fQ2G283pYLHQ4pdx4xGBo0blJzGwygVN+3KastVKLBFNdQqrtuE2IK8Tn2WfDOwxnVNKoOv3MlhCagSVbD3LP7LX8sC+b5N6tuWdKf7olNvG+d08JHNjszGgqbUXsWwsl3gXNohK9CWLI0SQR00im7pomz1/jNpUlnEv7Xcr1g6+vU1yWEJqJohIPry7ZwROf/UBBsYffjenGteN6EhXWjKYQFhfAvnVHWxG7V0L6RlCP83p8p2NbER1OgQhb7dScWFS1zr0AlhCamf1Z+Tz80Ube+y6NDvER3JnSj4kD2jW9biRfFWTD3tXH3iNxePvR11v1OnY8ot3JzmJ/xjRBlhCaqWXbD3H3h+vYsCeTUT0TuXdqP3q2aZqL09Va7qFjWxFpKyHbO4/BFQJt+jpdTaVJonVfcDejlpZpsiwhNGPFJR7e+HYnj326idzCEn4zqhvXndmLmHD7cDtO5u7j12zK9858Dol07okof49EQneb2WROOJYQDAeyC3j0k028vfwn2saFc/ukvkwd1KH5diP5QhUObTs2SexZBcXejerD46HDIIhuA6ERTtKo73drhZgAs4Rgyny38zB3f7iONWkZDO+ewMypA+jdzrqRfFZS7AxSl08Q+UegKN9JFKXf68oVAqFREBJRx6QS4Yx/lH4PjawhAYXa1NxmxhKCOUaJR3lr2U4e/XQTWfnFXD6iKzdO6EVchK3v7xeqzmyn8gmi0u/5UJRXxffc2tUtXR+qtsTlv+TiyzlCIiwBBZklBFOpwzmFPDp/E29+uxMBklpG0iUhmi6toujayvnepVU0nROiiAxrIndAN1UlRdUkl5qSTHV1Kn731ivxcfP6yoSUJooo35OIL9+rSlg2znMMSwimWmvTMvh03V52HMxlx6FcdhzM4UjusXdZtouLoHOrKLp6k8TRhBFFrLUsmh9PydFE4XMy8THZVHbO0mXU68IdVvdkU5fE5G7c74eG3g/BnGAGJMUzIOnYm7OO5BYeTRAHcth+0EkUCzalk56165iyraLDvMniaOui9HnLKFvquElyuZ1VaBtqJVrVGpJITd+rSFyF2c6OgJXVKb2ZsbbE7b/kUtVYUmQCRLbw668YLCGYKrSICqNFVBiDOrU47rWcgmJ2HMxl56GjiWLHwVy+/fEQH3yfRvlGZ2xESFnXU2nroktCFF0To2kTa1tMGh+JHP1QbQiqTjdcrZOMDwnquEkI3vq1Wfto5A0w4T6//9iWEEytRYeH0K9DHP06xB33Wn5RCbsO57LjYO4xyWJdWgafrN1LiedotogMddM5wel26pro7YLyjmF0aBGJ22XJwgSJiLPEekhYwy1tUlJcLrnUkFRa9w5ICJYQjF9FhLrp2Sa20juii0o87D6S53RFHSxtXeTy44EcUn9Ip7D4aBM91C10ahl1fOuiVRQdW0YRFmIDhaaJcYeAOwbCY4IWgiUE02BC3S7vh3o0cOyqox6Psjcz/5hksfNQDtsPOF1ROYVHp1W6BDq0iDxmYLt0oNtmRBlTd5YQTKPgcgkdWkTSoUUkI3q0OuY1VeVAdmFZgthxMIcdh5wuqXlr9hw3I6ptXPhxrYrSgW6718KYqgUkIYjIi0A/YJ6qPuBLGREJAbZ5vwCuU9U1gYjPnFhEhNax4bSODWdIl4TjXs/ILWJH6QD3gZyyqbOVzYhKiA47miASouiaeLR1YTOiTHPn94QgIucDblUdISIviUgvVd1cUxkgFnhTVW/xd0ymaYuPCmVgVAsGdmxx3Gs5BcXsPHTsmMWOgzmVz4gKD6FLYrmZUKWtC5sRZZqJQLQQkoF3vI/nA6OAzT6UiQRSRGQcsAa4SvXYDU9FZAYwA6Bz584BCN00NdHhIfRtH0ff9lXNiMo7Ombh/b4uLYNP1+6luNyMqIhQV9kMqC4Vbs6LCQ8hNMRFqFsIdblw2ewoc4IKREKIBtK8jw8Bg30s8wVwlqruEZFXgUnA7PKVVPU54Dlw7lT2f+imOXFmRMXQs83xszqKSzzsPpLP9oM5ZVNnt1cxI6oit0uc5OB2EeZ2Eep2ERriPA91lXtc9vrR52WPQ6p5rez1Kl5zuwgLOfZ5+dfDysUT4hJr+ZgygUgI2Th/7QPEAJXND6yszGpVLfAeWw70CkBsxvgkxO2ic6soOreKorIZUfuy8tl+IJefDuWSV1RCUYmHwhIPRcVKUYnn6PMSD8Ul6n2sFBUf+1peUQlZ+R4KS47WKyo+9nlp/UAJc7sIOSZhiLfFUzGZVExyR1tFpQkmrHwSCvG+Vu58YeXPGeI65vWwCtcLC3ESVvnX7N6UwApEQliB0wW0FBgEbPKxzGsi8iCwFjgPmBWA2IypN5dLaB8fSfv442dEBYqqUuzxJoliLUsoRaWJptzzwmKt+rVySen4173nLa76teyC4rIYiko8FHmOPi4sV7b8DYj+5BLKEssxSSzk+FbQsa9XaEG5hZDyCbAswR37WqhbjkuAzrlrfu1E7D4MREL4AFgkIh2AicBFIvKAqt5ZTZnhwGrgDUCA2ar6eQBiM+aEJHK0G4qwYEdTsxJv8ir2VGwVeZOH91jp64UVEpDzulLsOfr4mJZXsfPa8Qnw2KSXU1hyXAKs2HKrrvuvvkJcR1tXYd6EE1KxpVWxRVRFl2H510/vlsDInon+j9ffJ1TVTBFJBiYAj6jqXmBVDWUygAxgoL/jMcY0PLdLcLu8NwiGBzeWmqiqN4Ed2/IqLv/8uFZZhRZUta02LUuA5ZNScYUEmVNQfPS59/oVE2RpEr06uceJkRAAVPUwR2cR1bmMMcYEmogQ4hZC3BBJ47/L3eNRAjWjxu5UNsaYE0ggxyVshTBjjDGAJQRjjDFelhCMMcYAlhCMMcZ4WUIwxhgDWEIwxhjjZQnBGGMMAKJ6Yi4aKiLpwI5KXkoEDjRwOL6y2OqmMccGjTs+i63uGnN89Ymti6q2ruyFEzYhVEVElqvq0GDHURmLrW4ac2zQuOOz2OquMccXqNisy8gYYwxgCcEYY4xXU0wIzwU7gGpYbHXTmGODxh2fxVZ3jTm+gMTW5MYQjDHG1E1TbCEYY4ypA0sIxhhjgCaUEETkRRFZIiJ31lw68EQkXkQ+FpH5IvK+iIQ1whjbish33seNKjYAEfm7iEzxPm4U8YlISxH5SESWi8g/Gkts3n/LReWeHxdTMOMsH19l741gxlfxd1fu2Hflnjem2MreF/6OrUkkBBE5H3Cr6gigu4j0CnZMwCXA46p6NrAXuIjGF+NjQGRj/P2JyGignarOaWTxXQq87p0DHisi/xvs2ESkJfAKEO19ftzvK5i/w4rxcfx749xgxVdJbKUeAyK9ZRpNbOXfF4GIrUkkBCCZo9txzgdGBS8Uh6r+XVU/8z5tDfyKRhSjiIwHcnDekMk0rthCgeeB7SIyjcYV30FggIi0ADoB3Qh+bCXAhUCm93lyJTFVdqyhHBNfJe+N/UGMr+LvruJ7g8YSWyXvC7/H1lQSQjSQ5n18CGgbxFiOISIjgJbATzSSGL1N9LuAW72HGtvv7zJgPfAIcDpwLY0nvsVAF+B6YAMQRpBjU9VMVc0od6iyf8+g/RtXEh9w9L2hqkuDFV/F2Cp5b9BYYqPC+0JErvN3bE0lIWTjbd4BMTSSn0tEEoCngF/TuGK8Ffi7qh7xPm9MsQGcCjynqnuBfwELaTzx3QP8XlXvAzYCF9N4YitV2b9no/o3rvDegMYTX8X3BjSe2Cq+L8b5O7bG8J/XH1ZwtKk0CNgevFAc3r80/g3cpqo7aFwxngVcKyKpwCnAFBpPbABbgO7ex0OBrjSe+FoCJ4uIGxgGPEzjia1UZf/XGs3/v0reG9B44jvmvSEiL9B4Yqv4vvD/54qqnvBfQBywCngcpxkf3whiuho4DKR6vy5vbDF640xtbL8/IBbnA2MhsASni6ZRxIfThbUO5y+zzxrT7w5I9X4/LqbGEGe5+Cq+Ny4Mdnylsfn6+wzS763i+yLJ37E1mTuVvSPyE4CF6jSpGp3GHGNjjg0ad3yNMbbKYmqMcZbXmONrLrE1mYRgjDGmfprKGIIxxph6soRgjDEGsIRgTK2IiFR43l9EBtSifisRsfedaZTsP6YxFYjI/SLS1fv4IhF5SET+IyKbgJkVij8C3CcioSLSQUT2ikiqiBwUkaQK5xVgLnBNJdcME5F7RORSEfmdN4YwEfkkMD+lMcezhGCaNRF5WURGiUiMiHwvIicDHwD/9t5rcCXwNjBDVXur6t3l6l6Gc5foHOATnBuDPlHVZOBbVU2rcLk/At8C00Wkb4XX4nDej32BnkArYAzOVEJExF2xdWKMv4UEOwBjGom/A0+p6hoAEUlR1RIRKcaZ/93X+3nsBtYCpwEzgBeBrcBbwBneuqfgzA0vIyJX49xZejvOnaVvicjtqjrPW6Sd9zrXAV/g3HD0G6CHiHyLs+bPWGBnIH54Y8ASgjEAVwAxqvqi94P7QuANnG0Kw3DuSO6Nc4PcApxWQQEwDTgJGKGqj4tIIs5iY0OAHwG8LYFZ3vIXAA/htCimAm+KyI3ATUAu0AP4P5wP/2icBDIB6Aj0VlVLBiagLCEY43zw5oiIS1WfEZEN3mMAEar6mIhMBIap6kMAIpKF002U433+M5xlnQFeBVJF5BWcu4T/rapveMvlAyWqukNERuEsi74Tp4VwNc5aSTOBfsAAnOQSDmwL6G/AGCwhGAPOaqqXeL9e8x5T79ryWd7n4v1yXlTdB5zmHWdIAUbj/JWPqhaJyOfAOar6IbC0souqqgenJYKIjANuBhJxltVuh9PaeBYo5NjVN40JCEsIxjjrEt0LzBORt8odfwR42vvYhTN+UEZERgJ343QrnQeEeo+PAUbijDX4RFXfE5FhOElnF1CkqpneFkWbxrZcgmmabJaRMYCqbsVZNGwGzpLMv/Y+T/UW2YizAQml9xGo6tc4g8d56qxbX9qCiAReBt6t5FJC1e+723EWfbsMOEtEuuC0FBJEpHsVdYzxG0sIpllT1StUdbH38QxAcbqJJuJsNvKFiKzEmUX0pIik4Qw6l7oNWC0iEXhbCKr6qar+SytfKCwUp0VxDBHpgbPzlQcYgbN14j9wZh39HmdWUoIffmRjqmSL2xlTTulc/8o+zEUkBKfbqLCKD/v6XjtEVYu9j92qWlI+rkBc05jyLCEYY4wBrMvIGGOMlyUEY4wxgCUEY4wxXpYQjDHGAJYQjDHGeP0/+8ex0AJ3UIMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Coverage')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Coverage\")\n",
    "    plt.title(\"Coverage\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "519e7212",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x21f03bed100>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Popularity')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Popularity\")\n",
    "    plt.title(\"Popularity\")\n",
    "plt.legend()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
